{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example Q3 - Variational classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In example Q3 we show how to use PennyLane to implement variational quantum classifiers - quantum circuits that can be trained from labelled data to classify new data samples. The architecture is inspired by [Farhi and Neven (2018)](https://arxiv.org/abs/1802.06002) as well as [Schuld et al. (2018)](https://arxiv.org/abs/1804.00633). \n",
    "\n",
    "We will first show that the variational quantum classifier can reproduce the parity function\n",
    "\n",
    "$$ f: x \\in \\{0,1\\}^{\\otimes n} \\rightarrow y = \\begin{cases} 1 \\text{  if uneven number of ones in } x \\\\ 0 \\text{ otherwise} \\end{cases}.$$\n",
    "\n",
    "This optimization example demonstrates how to encode binary inputs into the initial state of the variational circuit, which is simply a computational basis state.\n",
    "\n",
    "We then show how to encode real vectors as amplitude vectors (*amplitude encoding*) and train the model to recognize the first two classes of flowers in the Iris dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Fitting the parity function "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports\n",
    "As before, we import PennyLane, the PennyLane-provided version of NumPy, and an optimizer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "from pennylane import numpy as np\n",
    "from pennylane.optimize import NesterovMomentumOptimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quantum and classical nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We create a quantum device with four \"wires\" (or qubits)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device('default.qubit', wires=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variational classifiers usually define a \"layer\" or \"block\", which is an elementary circuit architecture that gets repeated to build the variational circuit.\n",
    "\n",
    "<IMage>\n",
    "\n",
    "Our circuit layer consists of an arbitrary rotation on every qubit, as well as CNOTs that entangle each qubit with its neighbour.\n",
    "\n",
    "<IMage>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def layer(W):\n",
    "\n",
    "    qml.Rot(W[0, 0], W[0, 1], W[0, 2], wires=0)\n",
    "    qml.Rot(W[1, 0], W[1, 1], W[1, 2], wires=1)\n",
    "    qml.Rot(W[2, 0], W[2, 1], W[2, 2], wires=2)\n",
    "    qml.Rot(W[3, 0], W[3, 1], W[3, 2], wires=3)\n",
    "\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    qml.CNOT(wires=[1, 2])\n",
    "    qml.CNOT(wires=[2, 3])\n",
    "    qml.CNOT(wires=[3, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also need a way to encode data inputs $x$ into the circuit, so that the measured output depends on the inputs. In this first example, the inputs are bitstrings, which we encode into the state of the qubits. The quantum state $|\\psi \\rangle $ after state preparation is a computational basis state that has 1s where $x$ has 1s, for example\n",
    "\n",
    "$$ x = 0101 \\rightarrow |\\psi \\rangle = |0101 \\rangle . $$\n",
    "\n",
    "We use the `BasisState` function provided by PennyLane, which expects `x` to be a list of zeros and ones, i.e. `[0,1,0,1]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def statepreparation(x):\n",
    "\n",
    "    qml.BasisState(x, wires=[0, 1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we define the quantum node as a state preparation routine, followed by a repetition of the layer structure. Borrowing from machine learning, we call the parameters `weights`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev)\n",
    "def circuit(weights, x=None):\n",
    "\n",
    "    statepreparation(x)\n",
    "\n",
    "    for W in weights:\n",
    "        layer(W)\n",
    "\n",
    "    return qml.expval.PauliZ(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different from previous examples, the quantum node takes the data as a keyword argument `x` (with the default value `None`). Keyword arguments of a quantum node are considered as fixed when calculating a gradient; they are never trained."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to add a \"classical\" bias parameter, the variational quantum classifer also needs some post-processing. We define the final model by a classical node that uses the first variable, and feeds the remainder into the quantum node. Before this, we reshape the list of remaining variables for easy use in the quantum node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def variational_classifier(var, x=None):\n",
    "\n",
    "    weights = var[0]\n",
    "    bias = var[1]\n",
    "\n",
    "    return circuit(weights, x=x) + bias"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In supervised learning, the cost function is usually the sum of a loss function and a regularizer. We use the standard square loss that measures the distance between target labels and model predictions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square_loss(labels, predictions):\n",
    "\n",
    "    loss = 0\n",
    "    for l, p in zip(labels, predictions):\n",
    "        loss = loss + (l - p) ** 2\n",
    "    loss = loss / len(labels)\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To monitor how many inputs the current classifier predicted correctly, we also define the accuracy given target labels and model predictions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy(labels, predictions):\n",
    "\n",
    "    loss = 0\n",
    "    for l, p in zip(labels, predictions):\n",
    "        if abs(l - p) < 1e-5:\n",
    "            loss = loss + 1\n",
    "    loss = loss / len(labels)\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For learning tasks, the cost depends on the data - here the features and labels considered in the iteration of the optimization routine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cost(var, X, Y):\n",
    "\n",
    "    predictions = [variational_classifier(var, x=x) for x in X]\n",
    "\n",
    "    return square_loss(Y, predictions) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now load and preprocess some data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X = [0. 0. 0. 0.], Y = -1\n",
      "X = [0. 0. 0. 1.], Y =  1\n",
      "X = [0. 0. 1. 0.], Y =  1\n",
      "X = [0. 0. 1. 1.], Y = -1\n",
      "X = [0. 1. 0. 0.], Y =  1\n",
      "...\n"
     ]
    }
   ],
   "source": [
    "data = np.loadtxt(\"data/parity.txt\")\n",
    "X = data[:, :-1]\n",
    "Y = data[:, -1]\n",
    "Y = Y * 2 - np.ones(len(Y))  # shift label from {0, 1} to {-1, 1}\n",
    "\n",
    "for i in range(5):\n",
    "    print('X = {}, Y = {: d}'.format(X[i], int(Y[i])))\n",
    "print('...')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We initialize the variables randomly (but fix a seed for reproducability). The first variable in the list is used as a bias, while the rest is fed into the gates of the variational circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[[ 0.01764052,  0.00400157,  0.00978738],\n",
       "         [ 0.02240893,  0.01867558, -0.00977278],\n",
       "         [ 0.00950088, -0.00151357, -0.00103219],\n",
       "         [ 0.00410599,  0.00144044,  0.01454274]],\n",
       " \n",
       "        [[ 0.00761038,  0.00121675,  0.00443863],\n",
       "         [ 0.00333674,  0.01494079, -0.00205158],\n",
       "         [ 0.00313068, -0.00854096, -0.0255299 ],\n",
       "         [ 0.00653619,  0.00864436, -0.00742165]]]), 0.0)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "num_qubits = 4\n",
    "num_layers = 2\n",
    "var_init = (0.01 * np.random.randn(num_layers, num_qubits, 3), 0.0)\n",
    "\n",
    "var_init"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we create an optimizer and choose a batch size..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt = NesterovMomentumOptimizer(0.5)\n",
    "batch_size = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...and train the optimizer. We track the accuracy - the share of correctly classified data samples. For this we compute the outputs of the variational classifier and turn them into predictions in $\\{-1,1\\}$ by taking the sign of the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter:     1 | Cost: 3.4355534 | Accuracy: 0.5000000 \n",
      "Iter:     2 | Cost: 1.9287800 | Accuracy: 0.5000000 \n",
      "Iter:     3 | Cost: 2.0341238 | Accuracy: 0.5000000 \n",
      "Iter:     4 | Cost: 1.6372574 | Accuracy: 0.5000000 \n",
      "Iter:     5 | Cost: 1.3025395 | Accuracy: 0.6250000 \n",
      "Iter:     6 | Cost: 1.4555019 | Accuracy: 0.3750000 \n",
      "Iter:     7 | Cost: 1.4492786 | Accuracy: 0.5000000 \n",
      "Iter:     8 | Cost: 0.6510286 | Accuracy: 0.8750000 \n",
      "Iter:     9 | Cost: 0.0566074 | Accuracy: 1.0000000 \n",
      "Iter:    10 | Cost: 0.0053045 | Accuracy: 1.0000000 \n",
      "Iter:    11 | Cost: 0.0809483 | Accuracy: 1.0000000 \n",
      "Iter:    12 | Cost: 0.1115426 | Accuracy: 1.0000000 \n",
      "Iter:    13 | Cost: 0.1460257 | Accuracy: 1.0000000 \n",
      "Iter:    14 | Cost: 0.0877037 | Accuracy: 1.0000000 \n",
      "Iter:    15 | Cost: 0.0361311 | Accuracy: 1.0000000 \n",
      "Iter:    16 | Cost: 0.0040937 | Accuracy: 1.0000000 \n",
      "Iter:    17 | Cost: 0.0004899 | Accuracy: 1.0000000 \n",
      "Iter:    18 | Cost: 0.0005290 | Accuracy: 1.0000000 \n",
      "Iter:    19 | Cost: 0.0024304 | Accuracy: 1.0000000 \n",
      "Iter:    20 | Cost: 0.0062137 | Accuracy: 1.0000000 \n",
      "Iter:    21 | Cost: 0.0088864 | Accuracy: 1.0000000 \n",
      "Iter:    22 | Cost: 0.0201912 | Accuracy: 1.0000000 \n",
      "Iter:    23 | Cost: 0.0060335 | Accuracy: 1.0000000 \n",
      "Iter:    24 | Cost: 0.0036153 | Accuracy: 1.0000000 \n",
      "Iter:    25 | Cost: 0.0012741 | Accuracy: 1.0000000 \n"
     ]
    }
   ],
   "source": [
    "var = var_init\n",
    "for it in range(25):\n",
    "\n",
    "    # Update the weights by one optimizer step\n",
    "    batch_index = np.random.randint(0, len(X), (batch_size, ))\n",
    "    X_batch = X[batch_index]\n",
    "    Y_batch = Y[batch_index]\n",
    "    var = opt.step(lambda v: cost(v, X_batch, Y_batch), var)\n",
    "\n",
    "    # Compute accuracy\n",
    "    predictions = [np.sign(variational_classifier(var, x=x)) for x in X]\n",
    "    acc = accuracy(Y, predictions)\n",
    "\n",
    "    print(\"Iter: {:5d} | Cost: {:0.7f} | Accuracy: {:0.7f} \".format(it + 1, cost(var, X, Y), acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Iris classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quantum and classical nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To encode real-valued vectors into the amplitudes of a quantum state, we use a 2-qubit simulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device('default.qubit', wires=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "State preparation is not as simple as when we represent a bitstring with a basis state. Every input x has to be translated into a set of angles which can get fed into a small routine for state preparation. To simplify things a bit, we will work with data from the positive subspace, so that we can ignore signs (which would require another cascade of rotations around the z axis).\n",
    "\n",
    "The circuit is coded according to the scheme in [Möttönen, et al. (2004)](https://arxiv.org/abs/quant-ph/0407010), or - as presented for positive vectors only - in [Schuld and Petruccione (2018)](https://link.springer.com/book/10.1007/978-3-319-96424-9). We had to also decompose controlled Y-axis rotations into more basic circuits following [Nielsen and Chuang (2010)](http://www.michaelnielsen.org/qcqi/). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_angles(x):\n",
    "\n",
    "    beta0 = 2 * np.arcsin(np.sqrt(x[1]) ** 2 / np.sqrt(x[0] ** 2 + x[1] ** 2 + 1e-12) )\n",
    "    beta1 = 2 * np.arcsin(np.sqrt(x[3]) ** 2 / np.sqrt(x[2] ** 2 + x[3] ** 2 + 1e-12) )\n",
    "    beta2 = 2 * np.arcsin(np.sqrt(x[2] ** 2 + x[3] ** 2) / np.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2 + x[3] ** 2))\n",
    "\n",
    "    return np.array([beta2, -beta1 / 2, beta1 / 2, -beta0 / 2, beta0 / 2])\n",
    "\n",
    "\n",
    "def statepreparation(a):\n",
    "\n",
    "    qml.RY(a[0], wires=0)\n",
    "\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    qml.RY(a[1], wires=1)\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    qml.RY(a[2], wires=1)\n",
    "\n",
    "    qml.PauliX(wires=0)\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    qml.RY(a[3], wires=1)\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    qml.RY(a[4], wires=1)\n",
    "    qml.PauliX(wires=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test if this routine actually works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x               :  [0.53896774 0.79503606 0.27826503 0.        ]\n",
      "angles          :  [ 0.56397465 -0.          0.         -0.97504604  0.97504604]\n",
      "amplitude vector:  [ 5.38967743e-01  7.95036065e-01  2.78265032e-01 -1.38777878e-17]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([0.53896774, 0.79503606, 0.27826503, 0.])\n",
    "ang = get_angles(x)\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def test(angles=None):\n",
    "\n",
    "    statepreparation(angles)\n",
    "\n",
    "    return qml.expval.PauliZ(0)\n",
    "\n",
    "test(angles=ang)\n",
    "\n",
    "print(\"x               : \", x)\n",
    "print(\"angles          : \", ang)\n",
    "print(\"amplitude vector: \", np.real(dev._state))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the `default.qubit` simulator provides a shortcut to `statepreparation` with the command `qml.QubitStateVector(x, wires=[0, 1])`. However, some devices may not support an arbitrary state-preparation routine."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we are working with only 2 qubits now, we need to update the layer function as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def layer(W):\n",
    "\n",
    "    qml.Rot(W[0, 0], W[0, 1], W[0, 2], wires=0)\n",
    "    qml.Rot(W[1, 0], W[1, 1], W[1, 2], wires=1)\n",
    "\n",
    "    qml.CNOT(wires=[0, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variational classifier model and its cost remain essentially the same, but we have to reload them with the new state preparation and layer functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev)\n",
    "def circuit(weights, angles=None):\n",
    "\n",
    "    statepreparation(angles)\n",
    "    \n",
    "    for W in weights:\n",
    "        layer(W)\n",
    "\n",
    "    return qml.expval.PauliZ(0)\n",
    "\n",
    "\n",
    "def variational_classifier(var, angles=None):\n",
    "\n",
    "    weights = var[0]\n",
    "    bias = var[1]\n",
    "\n",
    "    return circuit(weights, angles=angles) + bias\n",
    "\n",
    "def cost(weights, features, labels):\n",
    "\n",
    "    predictions = [variational_classifier(weights, angles=f) for f in features]\n",
    "\n",
    "    return square_loss(labels, predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then load the Iris data set. There is a bit of preprocessing to do in order to encode the inputs into the amplitudes of a quantum state. In the last preprocessing step, we translate the inputs x to rotation angles using the `get_angles` function we defined above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First X sample (original)  : [0.4  0.75]\n",
      "First X sample (padded)    : [0.4  0.75 0.3  0.  ]\n",
      "First X sample (normalized): [0.44376016 0.83205029 0.33282012 0.        ]\n",
      "First features sample      : [ 0.67858523 -0.          0.         -1.080839    1.080839  ]\n"
     ]
    }
   ],
   "source": [
    "data = np.loadtxt(\"data/iris_classes1and2_scaled.txt\")\n",
    "X = data[:, 0:2]\n",
    "print(\"First X sample (original)  :\", X[0])\n",
    "\n",
    "# pad the vectors to size 2^2 with constant values\n",
    "padding = 0.3 * np.ones((len(X), 1))\n",
    "X_pad = np.c_[np.c_[X, padding], np.zeros((len(X), 1)) ] \n",
    "print(\"First X sample (padded)    :\", X_pad[0])\n",
    "\n",
    "# normalize each input\n",
    "normalization = np.sqrt(np.sum(X_pad ** 2, -1))\n",
    "X_norm = (X_pad.T / normalization).T  \n",
    "print(\"First X sample (normalized):\", X_norm[0])\n",
    "\n",
    "# angles for state preparation are new features\n",
    "features = np.array([get_angles(x) for x in X_norm])  \n",
    "print(\"First features sample      :\", features[0])\n",
    "\n",
    "Y = data[:, -1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These angles are our new features, which is why we have renamed X to \"features\" above. Let's plot the stages of preprocessing and play around with the dimensions (dim1, dim2). Some of them still separate the classes well, while others are less informative.\n",
    "\n",
    "*Note: To run the following cell you need the matplotlib library.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.figure()\n",
    "plt.scatter(X[:,0][Y== 1], X[:,1][Y== 1], c='r', marker='o', edgecolors='k')\n",
    "plt.scatter(X[:,0][Y==-1], X[:,1][Y==-1], c='b', marker='o', edgecolors='k')\n",
    "plt.title(\"Original data\")\n",
    "plt.show()\n",
    "\n",
    "plt.figure()\n",
    "dim1 = 0\n",
    "dim2 = 1\n",
    "plt.scatter(X_norm[:,dim1][Y== 1], X_norm[:,dim2][Y== 1], c='r', marker='o', edgecolors='k')\n",
    "plt.scatter(X_norm[:,dim1][Y==-1], X_norm[:,dim2][Y==-1], c='b', marker='o', edgecolors='k')\n",
    "plt.title(\"Padded and normalised data (dims {} and {})\".format(dim1, dim2))\n",
    "plt.show()\n",
    "\n",
    "plt.figure()\n",
    "dim1 = 0\n",
    "dim2 = 3\n",
    "plt.scatter(features[:,dim1][Y== 1], features[:,dim2][Y== 1], c='r', marker='o', edgecolors='k')\n",
    "plt.scatter(features[:,dim1][Y==-1], features[:,dim2][Y==-1], c='b', marker='o', edgecolors='k')\n",
    "plt.title(\"Feature vectors (dims {} and {})\".format(dim1, dim2))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This time we want to generalize from the data samples. To monitor the generalization performance, the data is split into training and validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0)\n",
    "num_data = len(Y)\n",
    "num_train = int(0.75 * num_data)\n",
    "index = np.random.permutation(range(num_data))\n",
    "feats_train = features[index[:num_train]]\n",
    "Y_train = Y[index[:num_train]]\n",
    "feats_val = features[index[num_train:]]\n",
    "Y_val = Y[index[num_train:]]\n",
    "\n",
    "# We need these later for plotting\n",
    "X_train = X[index[: num_train]]\n",
    "X_val   = X[index[num_train :]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we initialize the variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_qubits = 2\n",
    "num_layers = 6\n",
    "var_init = (0.01 * np.random.randn(num_layers, num_qubits, 3), 0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again we optimize the cost. This may take a little patience."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter:     1 | Cost: 1.4490948 | Acc train: 0.4933333 | Acc validation: 0.5600000 \n",
      "Iter:     2 | Cost: 1.3309953 | Acc train: 0.4933333 | Acc validation: 0.5600000 \n",
      "Iter:     3 | Cost: 1.1582178 | Acc train: 0.4533333 | Acc validation: 0.5600000 \n",
      "Iter:     4 | Cost: 0.9795035 | Acc train: 0.4800000 | Acc validation: 0.5600000 \n",
      "Iter:     5 | Cost: 0.8857893 | Acc train: 0.6400000 | Acc validation: 0.7600000 \n",
      "Iter:     6 | Cost: 0.8587935 | Acc train: 0.7066667 | Acc validation: 0.7600000 \n",
      "Iter:     7 | Cost: 0.8496204 | Acc train: 0.7200000 | Acc validation: 0.6800000 \n",
      "Iter:     8 | Cost: 0.8200972 | Acc train: 0.7333333 | Acc validation: 0.6800000 \n",
      "Iter:     9 | Cost: 0.8027511 | Acc train: 0.7466667 | Acc validation: 0.6800000 \n",
      "Iter:    10 | Cost: 0.7695152 | Acc train: 0.8000000 | Acc validation: 0.7600000 \n",
      "Iter:    11 | Cost: 0.7437432 | Acc train: 0.8133333 | Acc validation: 0.9600000 \n",
      "Iter:    12 | Cost: 0.7569196 | Acc train: 0.6800000 | Acc validation: 0.7600000 \n",
      "Iter:    13 | Cost: 0.7887487 | Acc train: 0.6533333 | Acc validation: 0.7200000 \n",
      "Iter:    14 | Cost: 0.8401458 | Acc train: 0.6133333 | Acc validation: 0.6400000 \n",
      "Iter:    15 | Cost: 0.8651830 | Acc train: 0.5600000 | Acc validation: 0.6000000 \n",
      "Iter:    16 | Cost: 0.8726113 | Acc train: 0.5600000 | Acc validation: 0.6000000 \n",
      "Iter:    17 | Cost: 0.8389732 | Acc train: 0.6133333 | Acc validation: 0.6400000 \n",
      "Iter:    18 | Cost: 0.8004839 | Acc train: 0.6266667 | Acc validation: 0.6400000 \n",
      "Iter:    19 | Cost: 0.7592044 | Acc train: 0.6800000 | Acc validation: 0.7600000 \n",
      "Iter:    20 | Cost: 0.7332872 | Acc train: 0.7733333 | Acc validation: 0.8000000 \n",
      "Iter:    21 | Cost: 0.7184319 | Acc train: 0.8800000 | Acc validation: 0.9600000 \n",
      "Iter:    22 | Cost: 0.7336631 | Acc train: 0.8133333 | Acc validation: 0.7200000 \n",
      "Iter:    23 | Cost: 0.7503193 | Acc train: 0.6533333 | Acc validation: 0.6400000 \n",
      "Iter:    24 | Cost: 0.7608474 | Acc train: 0.5866667 | Acc validation: 0.5200000 \n",
      "Iter:    25 | Cost: 0.7443533 | Acc train: 0.6533333 | Acc validation: 0.6400000 \n",
      "Iter:    26 | Cost: 0.7383224 | Acc train: 0.7066667 | Acc validation: 0.6400000 \n",
      "Iter:    27 | Cost: 0.7322155 | Acc train: 0.7466667 | Acc validation: 0.6800000 \n",
      "Iter:    28 | Cost: 0.7384175 | Acc train: 0.6533333 | Acc validation: 0.6400000 \n",
      "Iter:    29 | Cost: 0.7393227 | Acc train: 0.6400000 | Acc validation: 0.6400000 \n",
      "Iter:    30 | Cost: 0.7251903 | Acc train: 0.7200000 | Acc validation: 0.6800000 \n",
      "Iter:    31 | Cost: 0.7125040 | Acc train: 0.7866667 | Acc validation: 0.6800000 \n",
      "Iter:    32 | Cost: 0.6932690 | Acc train: 0.9066667 | Acc validation: 0.9200000 \n",
      "Iter:    33 | Cost: 0.6800562 | Acc train: 0.9200000 | Acc validation: 1.0000000 \n",
      "Iter:    34 | Cost: 0.6763140 | Acc train: 0.9200000 | Acc validation: 0.9600000 \n",
      "Iter:    35 | Cost: 0.6790040 | Acc train: 0.8933333 | Acc validation: 0.8800000 \n",
      "Iter:    36 | Cost: 0.6936199 | Acc train: 0.7600000 | Acc validation: 0.7200000 \n",
      "Iter:    37 | Cost: 0.6767184 | Acc train: 0.8266667 | Acc validation: 0.8000000 \n",
      "Iter:    38 | Cost: 0.6712470 | Acc train: 0.8266667 | Acc validation: 0.8000000 \n",
      "Iter:    39 | Cost: 0.6747390 | Acc train: 0.7600000 | Acc validation: 0.7600000 \n",
      "Iter:    40 | Cost: 0.6845696 | Acc train: 0.6666667 | Acc validation: 0.6400000 \n",
      "Iter:    41 | Cost: 0.6703303 | Acc train: 0.7333333 | Acc validation: 0.7200000 \n",
      "Iter:    42 | Cost: 0.6238401 | Acc train: 0.8933333 | Acc validation: 0.8400000 \n",
      "Iter:    43 | Cost: 0.6028185 | Acc train: 0.9066667 | Acc validation: 0.9200000 \n",
      "Iter:    44 | Cost: 0.5936355 | Acc train: 0.9066667 | Acc validation: 0.9200000 \n",
      "Iter:    45 | Cost: 0.5722417 | Acc train: 0.9200000 | Acc validation: 0.9600000 \n",
      "Iter:    46 | Cost: 0.5617923 | Acc train: 0.9200000 | Acc validation: 0.9600000 \n",
      "Iter:    47 | Cost: 0.5413240 | Acc train: 0.9466667 | Acc validation: 1.0000000 \n",
      "Iter:    48 | Cost: 0.5239643 | Acc train: 0.9466667 | Acc validation: 1.0000000 \n",
      "Iter:    49 | Cost: 0.5100842 | Acc train: 0.9466667 | Acc validation: 1.0000000 \n",
      "Iter:    50 | Cost: 0.5006861 | Acc train: 0.9466667 | Acc validation: 1.0000000 \n",
      "Iter:    51 | Cost: 0.4821672 | Acc train: 0.9466667 | Acc validation: 1.0000000 \n",
      "Iter:    52 | Cost: 0.4579575 | Acc train: 0.9600000 | Acc validation: 1.0000000 \n",
      "Iter:    53 | Cost: 0.4397479 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
      "Iter:    54 | Cost: 0.4326879 | Acc train: 0.9600000 | Acc validation: 0.9200000 \n",
      "Iter:    55 | Cost: 0.4351511 | Acc train: 0.9466667 | Acc validation: 0.9200000 \n",
      "Iter:    56 | Cost: 0.4328988 | Acc train: 0.9333333 | Acc validation: 0.9200000 \n",
      "Iter:    57 | Cost: 0.4149892 | Acc train: 0.9333333 | Acc validation: 0.9200000 \n",
      "Iter:    58 | Cost: 0.3755246 | Acc train: 0.9600000 | Acc validation: 0.9200000 \n",
      "Iter:    59 | Cost: 0.3468994 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
      "Iter:    60 | Cost: 0.3297071 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n"
     ]
    }
   ],
   "source": [
    "opt = NesterovMomentumOptimizer(0.01)\n",
    "batch_size = 5\n",
    "\n",
    "# train the variational classifier\n",
    "var = var_init\n",
    "for it in range(60):\n",
    "\n",
    "    # Update the weights by one optimizer step\n",
    "    batch_index = np.random.randint(0, num_train, (batch_size, ))\n",
    "    feats_train_batch = feats_train[batch_index]\n",
    "    Y_train_batch = Y_train[batch_index]\n",
    "    var = opt.step(lambda v: cost(v, feats_train_batch, Y_train_batch), var)\n",
    "\n",
    "    # Compute predictions on train and validation set\n",
    "    predictions_train = [np.sign(variational_classifier(var, angles=f)) for f in feats_train]\n",
    "    predictions_val = [np.sign(variational_classifier(var, angles=f)) for f in feats_val]\n",
    "\n",
    "    # Compute accuracy on train and validation set\n",
    "    acc_train = accuracy(Y_train, predictions_train)\n",
    "    acc_val = accuracy(Y_val, predictions_val)\n",
    "\n",
    "    print(\"Iter: {:5d} | Cost: {:0.7f} | Acc train: {:0.7f} | Acc validation: {:0.7f} \"\n",
    "          \"\".format(it+1, cost(var, features, Y), acc_train, acc_val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can plot the continuous output of the variational classifier for the first two dimensions of the Iris data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "cm = plt.cm.RdBu\n",
    "\n",
    "# make data for decision regions\n",
    "xx, yy = np.meshgrid(np.linspace(0.0, 1.5, 20), np.linspace(0.0, 1.5, 20))\n",
    "X_grid = [np.array([x, y]) for x, y in zip(xx.flatten(), yy.flatten())] \n",
    "\n",
    "# preprocess grid points like data inputs above\n",
    "padding = 0.3 * np.ones((len(X_grid), 1))\n",
    "X_grid = np.c_[np.c_[X_grid, padding], np.zeros((len(X_grid), 1)) ]  # pad each input\n",
    "normalization = np.sqrt(np.sum(X_grid ** 2, -1))\n",
    "X_grid = (X_grid.T / normalization).T  # normalize each input\n",
    "features_grid = np.array([get_angles(x) for x in X_grid])  # angles for state preparation are new features\n",
    "predictions_grid = [variational_classifier(var, angles=f) for f in features_grid]\n",
    "Z = np.reshape(predictions_grid, xx.shape)\n",
    "\n",
    "# plot decision regions\n",
    "cnt = plt.contourf(xx, yy, Z, levels=np.arange(-1, 1.1, 0.1), cmap=cm, alpha=.8, extend='both')\n",
    "plt.contour(xx, yy, Z, levels=[0.0], colors=('black',), linestyles=('--',), linewidths=(0.8,))\n",
    "plt.colorbar(cnt, ticks=[-1, 0, 1])\n",
    "\n",
    "# plot data\n",
    "plt.scatter(X_train[:,0][Y_train==1], X_train[:,1][Y_train==1], c='b', marker='o', edgecolors='k', label=\"class 1 train\")\n",
    "plt.scatter(X_val[:,0][Y_val==1], X_val[:,1][Y_val==1], c='b', marker='^', edgecolors='k', label=\"class 1 validation\")\n",
    "plt.scatter(X_train[:,0][Y_train==-1], X_train[:,1][Y_train==-1], c='r', marker='o', edgecolors='k', label=\"class -1 train\")\n",
    "plt.scatter(X_val[:,0][Y_val==-1], X_val[:,1][Y_val==-1], c='r', marker='^', edgecolors='k', label=\"class -1 validation\")\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
